home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / devtools / flex-2.5.4.tar.gz / flex-2.5.4.tar / flex-2.5.4 / MISC / parse.c < prev    next >
C/C++ Source or Header  |  1996-09-10  |  36KB  |  1,453 lines
  1. #ifndef lint
  2. static char yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93";
  3. #endif
  4. #define YYBYACC 1
  5. #define YYMAJOR 1
  6. #define YYMINOR 9
  7. #define yyclearin (yychar=(-1))
  8. #define yyerrok (yyerrflag=0)
  9. #define YYRECOVERING (yyerrflag!=0)
  10. #define YYPREFIX "yy"
  11. #line 10 "./parse.y"
  12. /*-
  13.  * Copyright (c) 1990 The Regents of the University of California.
  14.  * All rights reserved.
  15.  *
  16.  * This code is derived from software contributed to Berkeley by
  17.  * Vern Paxson.
  18.  * 
  19.  * The United States Government has rights in this work pursuant
  20.  * to contract no. DE-AC03-76SF00098 between the United States
  21.  * Department of Energy and the University of California.
  22.  *
  23.  * Redistribution and use in source and binary forms are permitted provided
  24.  * that: (1) source distributions retain this entire copyright notice and
  25.  * comment, and (2) distributions including binaries display the following
  26.  * acknowledgement:  ``This product includes software developed by the
  27.  * University of California, Berkeley and its contributors'' in the
  28.  * documentation or other materials provided with the distribution and in
  29.  * all advertising materials mentioning features or use of this software.
  30.  * Neither the name of the University nor the names of its contributors may
  31.  * be used to endorse or promote products derived from this software without
  32.  * specific prior written permission.
  33.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  34.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  35.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  36.  */
  37.  
  38. /* $Header: /home/daffy/u0/vern/flex/RCS/parse.y,v 2.28 95/04/21 11:51:51 vern Exp $ */
  39.  
  40.  
  41. /* Some versions of bison are broken in that they use alloca() but don't
  42.  * declare it properly.  The following is the patented (just kidding!)
  43.  * #ifdef chud to fix the problem, courtesy of Francois Pinard.
  44.  */
  45. #ifdef YYBISON
  46. /* AIX requires this to be the first thing in the file.  What a piece.  */
  47. # ifdef _AIX
  48.  #pragma alloca
  49. # endif
  50. #endif
  51.  
  52. #include "flexdef.h"
  53.  
  54. /* The remainder of the alloca() cruft has to come after including flexdef.h,
  55.  * so HAVE_ALLOCA_H is (possibly) defined.
  56.  */
  57. #ifdef YYBISON
  58. # ifdef __GNUC__
  59. #  ifndef alloca
  60. #   define alloca __builtin_alloca
  61. #  endif
  62. # else
  63. #  if HAVE_ALLOCA_H
  64. #   include <alloca.h>
  65. #  else
  66. #   ifdef __hpux
  67. void *alloca ();
  68. #   else
  69. #    ifdef __TURBOC__
  70. #     include <malloc.h>
  71. #    else
  72. char *alloca ();
  73. #    endif
  74. #   endif
  75. #  endif
  76. # endif
  77. #endif
  78.  
  79. /* Bletch, ^^^^ that was ugly! */
  80.  
  81.  
  82. int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen;
  83. int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
  84.  
  85. int *scon_stk;
  86. int scon_stk_ptr;
  87.  
  88. static int madeany = false;  /* whether we've made the '.' character class */
  89. int previous_continued_action;    /* whether the previous rule's action was '|' */
  90.  
  91. /* Expand a POSIX character class expression. */
  92. #define CCL_EXPR(func) \
  93.     { \
  94.     int c; \
  95.     for ( c = 0; c < csize; ++c ) \
  96.         if ( isascii(c) && func(c) ) \
  97.             ccladd( currccl, c ); \
  98.     }
  99.  
  100. /* While POSIX defines isblank(), it's not ANSI C. */
  101. #define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
  102.  
  103. /* On some over-ambitious machines, such as DEC Alpha's, the default
  104.  * token type is "long" instead of "int"; this leads to problems with
  105.  * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
  106.  * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
  107.  * following should ensure that the default token type is "int".
  108.  */
  109. #define YYSTYPE int
  110.  
  111. #line 112 "y.tab.c"
  112. #define CHAR 257
  113. #define NUMBER 258
  114. #define SECTEND 259
  115. #define SCDECL 260
  116. #define XSCDECL 261
  117. #define NAME 262
  118. #define PREVCCL 263
  119. #define EOF_OP 264
  120. #define OPTION_OP 265
  121. #define OPT_OUTFILE 266
  122. #define OPT_PREFIX 267
  123. #define OPT_YYCLASS 268
  124. #define CCE_ALNUM 269
  125. #define CCE_ALPHA 270
  126. #define CCE_BLANK 271
  127. #define CCE_CNTRL 272
  128. #define CCE_DIGIT 273
  129. #define CCE_GRAPH 274
  130. #define CCE_LOWER 275
  131. #define CCE_PRINT 276
  132. #define CCE_PUNCT 277
  133. #define CCE_SPACE 278
  134. #define CCE_UPPER 279
  135. #define CCE_XDIGIT 280
  136. #define YYERRCODE 256
  137. short yylhs[] = {                                        -1,
  138.     0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
  139.     7,    7,    8,    9,    9,   10,   10,   10,    4,    4,
  140.     4,    5,   12,   12,   12,   12,   14,   11,   11,   11,
  141.    15,   15,   15,   16,   13,   13,   13,   13,   18,   18,
  142.    17,   19,   19,   20,   20,   20,   20,   20,   20,   20,
  143.    20,   20,   20,   20,   20,   21,   21,   23,   23,   23,
  144.    23,   24,   24,   24,   24,   24,   24,   24,   24,   24,
  145.    24,   24,   24,   22,   22,
  146. };
  147. short yylen[] = {                                         2,
  148.     5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
  149.     1,    1,    2,    2,    0,    3,    3,    3,    5,    5,
  150.     0,    0,    2,    1,    1,    1,    0,    4,    3,    0,
  151.     3,    1,    1,    1,    2,    3,    2,    1,    3,    1,
  152.     2,    2,    1,    2,    2,    2,    6,    5,    4,    1,
  153.     1,    1,    3,    3,    1,    3,    4,    4,    2,    2,
  154.     0,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  155.     1,    1,    1,    2,    0,
  156. };
  157. short yydefred[] = {                                      2,
  158.     0,    0,    6,    0,    7,    8,    9,   15,   21,    0,
  159.     4,    0,    0,   12,   11,    0,    0,    0,    0,   14,
  160.     0,    1,    0,   10,    0,    0,    0,    0,    0,   21,
  161.     0,   16,   17,   18,   29,   33,   34,    0,   32,    0,
  162.    26,   55,   52,   25,    0,   50,   75,    0,    0,    0,
  163.    24,    0,    0,    0,    0,   51,   28,    0,   20,   23,
  164.     0,    0,   61,    0,   19,    0,   37,    0,   41,    0,
  165.     0,   44,   45,   46,   31,   74,   53,   54,    0,    0,
  166.    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
  167.    72,   73,   56,   60,   36,    0,    0,   57,    0,   49,
  168.     0,   58,    0,   48,   47,
  169. };
  170. short yydgoto[] = {                                       1,
  171.     2,    4,    9,   13,   22,   10,   16,   11,   12,   20,
  172.    23,   50,   51,   29,   38,   39,   52,   53,   54,   55,
  173.    56,   61,   64,   94,
  174. };
  175. short yysindex[] = {                                      0,
  176.     0, -235,    0, -191,    0,    0,    0,    0,    0, -207,
  177.     0, -215,  -18,    0,    0, -202,    4,   26,   32,    0,
  178.    41,    0,  -35,    0, -168, -166, -165,   38, -180,    0,
  179.   -30,    0,    0,    0,    0,    0,    0,  -16,    0,  -40,
  180.     0,    0,    0,    0,   -2,    0,    0,   -2,    8,   93,
  181.     0,   -2,  -25,   -2,   15,    0,    0, -153,    0,    0,
  182.   -27,  -26,    0,  -88,    0,  -23,    0,   -2,    0,   15,
  183.  -150,    0,    0,    0,    0,    0,    0,    0,   -3,   65,
  184.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  185.     0,    0,    0,    0,    0,   -2,  -21,    0, -145,    0,
  186.  -116,    0,  -12,    0,    0,
  187. };
  188. short yyrindex[] = {                                      0,
  189.     0, -188,    0,    0,    0,    0,    0,    0,    0,    0,
  190.     0, -154,    1,    0,    0, -140,    0,    0,    0,    0,
  191.  -176,    0,  -28,    0,    0,    0,    0,    0,    0,    0,
  192.     0,    0,    0,    0,    0,    0,    0,    0,    0,  -32,
  193.     0,    0,    0,    0,    0,    0,    0,    0,   22,    0,
  194.     0,    0,  106,    7,  -10,    0,    0,    0,    0,    0,
  195.     0,    0,    0,    0,    0,  108,    0,    0,    0,   -7,
  196.     0,    0,    0,    0,    0,    0,    0,    0,    0,   46,
  197.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  198.     0,    0,    0,    0,    0,    9,    0,    0,    0,    0,
  199.     0,    0,    0,    0,    0,
  200. };
  201. short yygindex[] = {                                      0,
  202.     0,    0,    0,   92,  100,    0,    0,    0,    0,    0,
  203.     0,    0,   81,    0,    0,   69,    0,   27,   60,  -29,
  204.     0,    0,   66,    0,
  205. };
  206. #define YYTABLESIZE 326
  207. short yytable[] = {                                      43,
  208.    22,   30,   42,   47,   93,   22,   77,   30,  104,   48,
  209.    67,   22,   95,   30,   78,   46,   40,   22,   39,   21,
  210.     3,   69,  101,   43,   70,   43,   42,   58,   42,   43,
  211.    43,   47,   42,   42,   30,   43,   43,   48,   42,   42,
  212.    30,   21,   40,   46,   39,   57,   30,   40,   14,   39,
  213.    17,   18,   19,   40,   15,   39,   72,   73,   30,   24,
  214.    49,   30,   22,   45,   25,   22,   70,    5,    6,    7,
  215.     5,    5,    5,    8,   62,   36,    5,   74,   66,   27,
  216.    43,   37,   28,   42,   59,   27,   26,   30,   49,   98,
  217.    30,   30,   27,   32,   30,   33,   34,   68,   68,   35,
  218.    68,   63,   65,  100,   13,   13,   13,   97,   37,   99,
  219.    13,  102,  105,   43,   61,   38,   42,   35,    3,    3,
  220.     3,   40,   31,   30,    3,   60,   75,   96,   79,    0,
  221.    40,    0,   39,    0,    0,    0,    0,   71,   59,    0,
  222.     0,  103,    0,    0,    0,    0,    0,    0,    0,    0,
  223.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  224.     0,    0,    0,    0,    0,    0,    0,    0,   80,    0,
  225.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  226.    81,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  227.    91,   92,    0,    0,    0,    0,    0,    0,    0,    0,
  228.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  229.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  230.     0,    0,    0,   30,   30,   41,   42,   22,   22,   76,
  231.    30,   30,   43,   44,   22,   22,    0,    0,    0,    0,
  232.     0,    0,    0,    0,    0,    0,   43,    0,    0,   42,
  233.     0,    0,   43,   80,   42,   42,   30,   30,    0,    0,
  234.    43,    0,    0,   30,   30,   81,   82,   83,   84,   85,
  235.    86,   87,   88,   89,   90,   91,   92,    0,   61,    0,
  236.     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  237.    61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
  238.    61,   61,   59,    0,    0,    0,    0,    0,    0,    0,
  239.     0,    0,    0,    0,   59,   59,   59,   59,   59,   59,
  240.    59,   59,   59,   59,   59,   59,
  241. };
  242. short yycheck[] = {                                      10,
  243.     0,   34,   10,   34,   93,   34,   34,   40,  125,   40,
  244.    36,   40,   36,   46,   41,   46,   10,   46,   10,   60,
  245.   256,   47,   44,   34,   54,   36,   34,   44,   36,   40,
  246.    41,   34,   40,   41,   34,   46,   47,   40,   46,   47,
  247.    40,   60,   36,   46,   36,   62,   46,   41,  256,   41,
  248.   266,  267,  268,   47,  262,   47,   42,   43,   91,  262,
  249.    91,   94,   91,   94,   61,   94,   96,  259,  260,  261,
  250.   259,  260,  261,  265,   48,  256,  265,   63,   52,  256,
  251.    91,  262,   42,   91,  125,  262,   61,  123,   91,   93,
  252.   123,   91,   61,  262,   94,  262,  262,  124,  124,   62,
  253.   124,   94,   10,  125,  259,  260,  261,  258,  262,   45,
  254.   265,  257,  125,  124,   93,   10,  124,   10,  259,  260,
  255.   261,   30,   23,  123,  265,   45,   58,   68,   63,   -1,
  256.   124,   -1,  124,   -1,   -1,   -1,   -1,  123,   93,   -1,
  257.    -1,  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  258.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  259.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,
  260.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  261.   269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  262.   279,  280,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  263.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  264.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  265.    -1,   -1,   -1,  256,  257,  256,  257,  256,  257,  257,
  266.   263,  264,  263,  264,  263,  264,   -1,   -1,   -1,   -1,
  267.    -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,  257,
  268.    -1,   -1,  263,  257,  257,  263,  256,  257,   -1,   -1,
  269.   263,   -1,   -1,  263,  264,  269,  270,  271,  272,  273,
  270.   274,  275,  276,  277,  278,  279,  280,   -1,  257,   -1,
  271.    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  272.   269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
  273.   279,  280,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
  274.    -1,   -1,   -1,   -1,  269,  270,  271,  272,  273,  274,
  275.   275,  276,  277,  278,  279,  280,
  276. };
  277. #define YYFINAL 1
  278. #ifndef YYDEBUG
  279. #define YYDEBUG 0
  280. #endif
  281. #define YYMAXTOKEN 280
  282. #if YYDEBUG
  283. char *yyname[] = {
  284. "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  285. 0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
  286. 0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  287. 0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  288. 0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  289. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  290. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  291. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
  292. "SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
  293. "OPT_PREFIX","OPT_YYCLASS","CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL",
  294. "CCE_DIGIT","CCE_GRAPH","CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE",
  295. "CCE_UPPER","CCE_XDIGIT",
  296. };
  297. char *yyrule[] = {
  298. "$accept : goal",
  299. "goal : initlex sect1 sect1end sect2 initforrule",
  300. "initlex :",
  301. "sect1 : sect1 startconddecl namelist1",
  302. "sect1 : sect1 options",
  303. "sect1 :",
  304. "sect1 : error",
  305. "sect1end : SECTEND",
  306. "startconddecl : SCDECL",
  307. "startconddecl : XSCDECL",
  308. "namelist1 : namelist1 NAME",
  309. "namelist1 : NAME",
  310. "namelist1 : error",
  311. "options : OPTION_OP optionlist",
  312. "optionlist : optionlist option",
  313. "optionlist :",
  314. "option : OPT_OUTFILE '=' NAME",
  315. "option : OPT_PREFIX '=' NAME",
  316. "option : OPT_YYCLASS '=' NAME",
  317. "sect2 : sect2 scon initforrule flexrule '\\n'",
  318. "sect2 : sect2 scon '{' sect2 '}'",
  319. "sect2 :",
  320. "initforrule :",
  321. "flexrule : '^' rule",
  322. "flexrule : rule",
  323. "flexrule : EOF_OP",
  324. "flexrule : error",
  325. "scon_stk_ptr :",
  326. "scon : '<' scon_stk_ptr namelist2 '>'",
  327. "scon : '<' '*' '>'",
  328. "scon :",
  329. "namelist2 : namelist2 ',' sconname",
  330. "namelist2 : sconname",
  331. "namelist2 : error",
  332. "sconname : NAME",
  333. "rule : re2 re",
  334. "rule : re2 re '$'",
  335. "rule : re '$'",
  336. "rule : re",
  337. "re : re '|' series",
  338. "re : series",
  339. "re2 : re '/'",
  340. "series : series singleton",
  341. "series : singleton",
  342. "singleton : singleton '*'",
  343. "singleton : singleton '+'",
  344. "singleton : singleton '?'",
  345. "singleton : singleton '{' NUMBER ',' NUMBER '}'",
  346. "singleton : singleton '{' NUMBER ',' '}'",
  347. "singleton : singleton '{' NUMBER '}'",
  348. "singleton : '.'",
  349. "singleton : fullccl",
  350. "singleton : PREVCCL",
  351. "singleton : '\"' string '\"'",
  352. "singleton : '(' re ')'",
  353. "singleton : CHAR",
  354. "fullccl : '[' ccl ']'",
  355. "fullccl : '[' '^' ccl ']'",
  356. "ccl : ccl CHAR '-' CHAR",
  357. "ccl : ccl CHAR",
  358. "ccl : ccl ccl_expr",
  359. "ccl :",
  360. "ccl_expr : CCE_ALNUM",
  361. "ccl_expr : CCE_ALPHA",
  362. "ccl_expr : CCE_BLANK",
  363. "ccl_expr : CCE_CNTRL",
  364. "ccl_expr : CCE_DIGIT",
  365. "ccl_expr : CCE_GRAPH",
  366. "ccl_expr : CCE_LOWER",
  367. "ccl_expr : CCE_PRINT",
  368. "ccl_expr : CCE_PUNCT",
  369. "ccl_expr : CCE_SPACE",
  370. "ccl_expr : CCE_UPPER",
  371. "ccl_expr : CCE_XDIGIT",
  372. "string : string CHAR",
  373. "string :",
  374. };
  375. #endif
  376. #ifndef YYSTYPE
  377. typedef int YYSTYPE;
  378. #endif
  379. #ifdef YYSTACKSIZE
  380. #undef YYMAXDEPTH
  381. #define YYMAXDEPTH YYSTACKSIZE
  382. #else
  383. #ifdef YYMAXDEPTH
  384. #define YYSTACKSIZE YYMAXDEPTH
  385. #else
  386. #define YYSTACKSIZE 500
  387. #define YYMAXDEPTH 500
  388. #endif
  389. #endif
  390. int yydebug;
  391. int yynerrs;
  392. int yyerrflag;
  393. int yychar;
  394. short *yyssp;
  395. YYSTYPE *yyvsp;
  396. YYSTYPE yyval;
  397. YYSTYPE yylval;
  398. short yyss[YYSTACKSIZE];
  399. YYSTYPE yyvs[YYSTACKSIZE];
  400. #define yystacksize YYSTACKSIZE
  401. #line 776 "./parse.y"
  402.  
  403.  
  404. /* build_eof_action - build the "<<EOF>>" action for the active start
  405.  *                    conditions
  406.  */
  407.  
  408. void build_eof_action()
  409.     {
  410.     register int i;
  411.     char action_text[MAXLINE];
  412.  
  413.     for ( i = 1; i <= scon_stk_ptr; ++i )
  414.         {
  415.         if ( sceof[scon_stk[i]] )
  416.             format_pinpoint_message(
  417.                 "multiple <<EOF>> rules for start condition %s",
  418.                 scname[scon_stk[i]] );
  419.  
  420.         else
  421.             {
  422.             sceof[scon_stk[i]] = true;
  423.             sprintf( action_text, "case YY_STATE_EOF(%s):\n",
  424.                 scname[scon_stk[i]] );
  425.             add_action( action_text );
  426.             }
  427.         }
  428.  
  429.     line_directive_out( (FILE *) 0, 1 );
  430.  
  431.     /* This isn't a normal rule after all - don't count it as
  432.      * such, so we don't have any holes in the rule numbering
  433.      * (which make generating "rule can never match" warnings
  434.      * more difficult.
  435.      */
  436.     --num_rules;
  437.     ++num_eof_rules;
  438.     }
  439.  
  440.  
  441. /* format_synerr - write out formatted syntax error */
  442.  
  443. void format_synerr( msg, arg )
  444. char msg[], arg[];
  445.     {
  446.     char errmsg[MAXLINE];
  447.  
  448.     (void) sprintf( errmsg, msg, arg );
  449.     synerr( errmsg );
  450.     }
  451.  
  452.  
  453. /* synerr - report a syntax error */
  454.  
  455. void synerr( str )
  456. char str[];
  457.     {
  458.     syntaxerror = true;
  459.     pinpoint_message( str );
  460.     }
  461.  
  462.  
  463. /* format_warn - write out formatted warning */
  464.  
  465. void format_warn( msg, arg )
  466. char msg[], arg[];
  467.     {
  468.     char warn_msg[MAXLINE];
  469.  
  470.     (void) sprintf( warn_msg, msg, arg );
  471.     warn( warn_msg );
  472.     }
  473.  
  474.  
  475. /* warn - report a warning, unless -w was given */
  476.  
  477. void warn( str )
  478. char str[];
  479.     {
  480.     line_warning( str, linenum );
  481.     }
  482.  
  483. /* format_pinpoint_message - write out a message formatted with one string,
  484.  *                 pinpointing its location
  485.  */
  486.  
  487. void format_pinpoint_message( msg, arg )
  488. char msg[], arg[];
  489.     {
  490.     char errmsg[MAXLINE];
  491.  
  492.     (void) sprintf( errmsg, msg, arg );
  493.     pinpoint_message( errmsg );
  494.     }
  495.  
  496.  
  497. /* pinpoint_message - write out a message, pinpointing its location */
  498.  
  499. void pinpoint_message( str )
  500. char str[];
  501.     {
  502.     line_pinpoint( str, linenum );
  503.     }
  504.  
  505.  
  506. /* line_warning - report a warning at a given line, unless -w was given */
  507.  
  508. void line_warning( str, line )
  509. char str[];
  510. int line;
  511.     {
  512.     char warning[MAXLINE];
  513.  
  514.     if ( ! nowarn )
  515.         {
  516.         sprintf( warning, "warning, %s", str );
  517.         line_pinpoint( warning, line );
  518.         }
  519.     }
  520.  
  521.  
  522. /* line_pinpoint - write out a message, pinpointing it at the given line */
  523.  
  524. void line_pinpoint( str, line )
  525. char str[];
  526. int line;
  527.     {
  528.     fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
  529.     }
  530.  
  531.  
  532. /* yyerror - eat up an error message from the parser;
  533.  *         currently, messages are ignore
  534.  */
  535.  
  536. void yyerror( msg )
  537. char msg[];
  538.     {
  539.     }
  540. #line 541 "y.tab.c"
  541. #define YYABORT goto yyabort
  542. #define YYREJECT goto yyabort
  543. #define YYACCEPT goto yyaccept
  544. #define YYERROR goto yyerrlab
  545. int
  546. yyparse()
  547. {
  548.     register int yym, yyn, yystate;
  549. #if YYDEBUG
  550.     register char *yys;
  551.     extern char *getenv();
  552.  
  553.     if (yys = getenv("YYDEBUG"))
  554.     {
  555.         yyn = *yys;
  556.         if (yyn >= '0' && yyn <= '9')
  557.             yydebug = yyn - '0';
  558.     }
  559. #endif
  560.  
  561.     yynerrs = 0;
  562.     yyerrflag = 0;
  563.     yychar = (-1);
  564.  
  565.     yyssp = yyss;
  566.     yyvsp = yyvs;
  567.     *yyssp = yystate = 0;
  568.  
  569. yyloop:
  570.     if (yyn = yydefred[yystate]) goto yyreduce;
  571.     if (yychar < 0)
  572.     {
  573.         if ((yychar = yylex()) < 0) yychar = 0;
  574. #if YYDEBUG
  575.         if (yydebug)
  576.         {
  577.             yys = 0;
  578.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  579.             if (!yys) yys = "illegal-symbol";
  580.             printf("%sdebug: state %d, reading %d (%s)\n",
  581.                     YYPREFIX, yystate, yychar, yys);
  582.         }
  583. #endif
  584.     }
  585.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
  586.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  587.     {
  588. #if YYDEBUG
  589.         if (yydebug)
  590.             printf("%sdebug: state %d, shifting to state %d\n",
  591.                     YYPREFIX, yystate, yytable[yyn]);
  592. #endif
  593.         if (yyssp >= yyss + yystacksize - 1)
  594.         {
  595.             goto yyoverflow;
  596.         }
  597.         *++yyssp = yystate = yytable[yyn];
  598.         *++yyvsp = yylval;
  599.         yychar = (-1);
  600.         if (yyerrflag > 0)  --yyerrflag;
  601.         goto yyloop;
  602.     }
  603.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
  604.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  605.     {
  606.         yyn = yytable[yyn];
  607.         goto yyreduce;
  608.     }
  609.     if (yyerrflag) goto yyinrecovery;
  610. #ifdef lint
  611.     goto yynewerror;
  612. #endif
  613. yynewerror:
  614.     yyerror("syntax error");
  615. #ifdef lint
  616.     goto yyerrlab;
  617. #endif
  618. yyerrlab:
  619.     ++yynerrs;
  620. yyinrecovery:
  621.     if (yyerrflag < 3)
  622.     {
  623.         yyerrflag = 3;
  624.         for (;;)
  625.         {
  626.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
  627.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  628.             {
  629. #if YYDEBUG
  630.                 if (yydebug)
  631.                     printf("%sdebug: state %d, error recovery shifting\
  632.  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
  633. #endif
  634.                 if (yyssp >= yyss + yystacksize - 1)
  635.                 {
  636.                     goto yyoverflow;
  637.                 }
  638.                 *++yyssp = yystate = yytable[yyn];
  639.                 *++yyvsp = yylval;
  640.                 goto yyloop;
  641.             }
  642.             else
  643.             {
  644. #if YYDEBUG
  645.                 if (yydebug)
  646.                     printf("%sdebug: error recovery discarding state %d\n",
  647.                             YYPREFIX, *yyssp);
  648. #endif
  649.                 if (yyssp <= yyss) goto yyabort;
  650.                 --yyssp;
  651.                 --yyvsp;
  652.             }
  653.         }
  654.     }
  655.     else
  656.     {
  657.         if (yychar == 0) goto yyabort;
  658. #if YYDEBUG
  659.         if (yydebug)
  660.         {
  661.             yys = 0;
  662.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  663.             if (!yys) yys = "illegal-symbol";
  664.             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
  665.                     YYPREFIX, yystate, yychar, yys);
  666.         }
  667. #endif
  668.         yychar = (-1);
  669.         goto yyloop;
  670.     }
  671. yyreduce:
  672. #if YYDEBUG
  673.     if (yydebug)
  674.         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
  675.                 YYPREFIX, yystate, yyn, yyrule[yyn]);
  676. #endif
  677.     yym = yylen[yyn];
  678.     yyval = yyvsp[1-yym];
  679.     switch (yyn)
  680.     {
  681. case 1:
  682. #line 113 "./parse.y"
  683. { /* add default rule */
  684.             int def_rule;
  685.  
  686.             pat = cclinit();
  687.             cclnegate( pat );
  688.  
  689.             def_rule = mkstate( -pat );
  690.  
  691.             /* Remember the number of the default rule so we
  692.              * don't generate "can't match" warnings for it.
  693.              */
  694.             default_rule = num_rules;
  695.  
  696.             finish_rule( def_rule, false, 0, 0 );
  697.  
  698.             for ( i = 1; i <= lastsc; ++i )
  699.                 scset[i] = mkbranch( scset[i], def_rule );
  700.  
  701.             if ( spprdflt )
  702.                 add_action(
  703.                 "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
  704.             else
  705.                 add_action( "ECHO" );
  706.  
  707.             add_action( ";\n\tYY_BREAK\n" );
  708.             }
  709. break;
  710. case 2:
  711. #line 142 "./parse.y"
  712. { /* initialize for processing rules */
  713.  
  714.             /* Create default DFA start condition. */
  715.             scinstal( "INITIAL", false );
  716.             }
  717. break;
  718. case 6:
  719. #line 153 "./parse.y"
  720. { synerr( "unknown error processing section 1" ); }
  721. break;
  722. case 7:
  723. #line 157 "./parse.y"
  724. {
  725.             check_options();
  726.             scon_stk = allocate_integer_array( lastsc + 1 );
  727.             scon_stk_ptr = 0;
  728.             }
  729. break;
  730. case 8:
  731. #line 165 "./parse.y"
  732. { xcluflg = false; }
  733. break;
  734. case 9:
  735. #line 168 "./parse.y"
  736. { xcluflg = true; }
  737. break;
  738. case 10:
  739. #line 172 "./parse.y"
  740. { scinstal( nmstr, xcluflg ); }
  741. break;
  742. case 11:
  743. #line 175 "./parse.y"
  744. { scinstal( nmstr, xcluflg ); }
  745. break;
  746. case 12:
  747. #line 178 "./parse.y"
  748. { synerr( "bad start condition list" ); }
  749. break;
  750. case 16:
  751. #line 189 "./parse.y"
  752. {
  753.             outfilename = copy_string( nmstr );
  754.             did_outfilename = 1;
  755.             }
  756. break;
  757. case 17:
  758. #line 194 "./parse.y"
  759. { prefix = copy_string( nmstr ); }
  760. break;
  761. case 18:
  762. #line 196 "./parse.y"
  763. { yyclass = copy_string( nmstr ); }
  764. break;
  765. case 19:
  766. #line 200 "./parse.y"
  767. { scon_stk_ptr = yyvsp[-3]; }
  768. break;
  769. case 20:
  770. #line 202 "./parse.y"
  771. { scon_stk_ptr = yyvsp[-3]; }
  772. break;
  773. case 22:
  774. #line 207 "./parse.y"
  775. {
  776.             /* Initialize for a parse of one rule. */
  777.             trlcontxt = variable_trail_rule = varlength = false;
  778.             trailcnt = headcnt = rulelen = 0;
  779.             current_state_type = STATE_NORMAL;
  780.             previous_continued_action = continued_action;
  781.             in_rule = true;
  782.  
  783.             new_rule();
  784.             }
  785. break;
  786. case 23:
  787. #line 220 "./parse.y"
  788. {
  789.             pat = yyvsp[0];
  790.             finish_rule( pat, variable_trail_rule,
  791.                 headcnt, trailcnt );
  792.  
  793.             if ( scon_stk_ptr > 0 )
  794.                 {
  795.                 for ( i = 1; i <= scon_stk_ptr; ++i )
  796.                     scbol[scon_stk[i]] =
  797.                         mkbranch( scbol[scon_stk[i]],
  798.                                 pat );
  799.                 }
  800.  
  801.             else
  802.                 {
  803.                 /* Add to all non-exclusive start conditions,
  804.                  * including the default (0) start condition.
  805.                  */
  806.  
  807.                 for ( i = 1; i <= lastsc; ++i )
  808.                     if ( ! scxclu[i] )
  809.                         scbol[i] = mkbranch( scbol[i],
  810.                                     pat );
  811.                 }
  812.  
  813.             if ( ! bol_needed )
  814.                 {
  815.                 bol_needed = true;
  816.  
  817.                 if ( performance_report > 1 )
  818.                     pinpoint_message(
  819.             "'^' operator results in sub-optimal performance" );
  820.                 }
  821.             }
  822. break;
  823. case 24:
  824. #line 256 "./parse.y"
  825. {
  826.             pat = yyvsp[0];
  827.             finish_rule( pat, variable_trail_rule,
  828.                 headcnt, trailcnt );
  829.  
  830.             if ( scon_stk_ptr > 0 )
  831.                 {
  832.                 for ( i = 1; i <= scon_stk_ptr; ++i )
  833.                     scset[scon_stk[i]] =
  834.                         mkbranch( scset[scon_stk[i]],
  835.                                 pat );
  836.                 }
  837.  
  838.             else
  839.                 {
  840.                 for ( i = 1; i <= lastsc; ++i )
  841.                     if ( ! scxclu[i] )
  842.                         scset[i] =
  843.                             mkbranch( scset[i],
  844.                                 pat );
  845.                 }
  846.             }
  847. break;
  848. case 25:
  849. #line 280 "./parse.y"
  850. {
  851.             if ( scon_stk_ptr > 0 )
  852.                 build_eof_action();
  853.     
  854.             else
  855.                 {
  856.                 /* This EOF applies to all start conditions
  857.                  * which don't already have EOF actions.
  858.                  */
  859.                 for ( i = 1; i <= lastsc; ++i )
  860.                     if ( ! sceof[i] )
  861.                         scon_stk[++scon_stk_ptr] = i;
  862.  
  863.                 if ( scon_stk_ptr == 0 )
  864.                     warn(
  865.             "all start conditions already have <<EOF>> rules" );
  866.  
  867.                 else
  868.                     build_eof_action();
  869.                 }
  870.             }
  871. break;
  872. case 26:
  873. #line 303 "./parse.y"
  874. { synerr( "unrecognized rule" ); }
  875. break;
  876. case 27:
  877. #line 307 "./parse.y"
  878. { yyval = scon_stk_ptr; }
  879. break;
  880. case 28:
  881. #line 311 "./parse.y"
  882. { yyval = yyvsp[-2]; }
  883. break;
  884. case 29:
  885. #line 314 "./parse.y"
  886. {
  887.             yyval = scon_stk_ptr;
  888.  
  889.             for ( i = 1; i <= lastsc; ++i )
  890.                 {
  891.                 int j;
  892.  
  893.                 for ( j = 1; j <= scon_stk_ptr; ++j )
  894.                     if ( scon_stk[j] == i )
  895.                         break;
  896.  
  897.                 if ( j > scon_stk_ptr )
  898.                     scon_stk[++scon_stk_ptr] = i;
  899.                 }
  900.             }
  901. break;
  902. case 30:
  903. #line 331 "./parse.y"
  904. { yyval = scon_stk_ptr; }
  905. break;
  906. case 33:
  907. #line 339 "./parse.y"
  908. { synerr( "bad start condition list" ); }
  909. break;
  910. case 34:
  911. #line 343 "./parse.y"
  912. {
  913.             if ( (scnum = sclookup( nmstr )) == 0 )
  914.                 format_pinpoint_message(
  915.                     "undeclared start condition %s",
  916.                     nmstr );
  917.             else
  918.                 {
  919.                 for ( i = 1; i <= scon_stk_ptr; ++i )
  920.                     if ( scon_stk[i] == scnum )
  921.                         {
  922.                         format_warn(
  923.                             "<%s> specified twice",
  924.                             scname[scnum] );
  925.                         break;
  926.                         }
  927.  
  928.                 if ( i > scon_stk_ptr )
  929.                     scon_stk[++scon_stk_ptr] = scnum;
  930.                 }
  931.             }
  932. break;
  933. case 35:
  934. #line 366 "./parse.y"
  935. {
  936.             if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON )
  937.                 /* Provide final transition \now/ so it
  938.                  * will be marked as a trailing context
  939.                  * state.
  940.                  */
  941.                 yyvsp[0] = link_machines( yyvsp[0],
  942.                         mkstate( SYM_EPSILON ) );
  943.  
  944.             mark_beginning_as_normal( yyvsp[0] );
  945.             current_state_type = STATE_NORMAL;
  946.  
  947.             if ( previous_continued_action )
  948.                 {
  949.                 /* We need to treat this as variable trailing
  950.                  * context so that the backup does not happen
  951.                  * in the action but before the action switch
  952.                  * statement.  If the backup happens in the
  953.                  * action, then the rules "falling into" this
  954.                  * one's action will *also* do the backup,
  955.                  * erroneously.
  956.                  */
  957.                 if ( ! varlength || headcnt != 0 )
  958.                     warn(
  959.         "trailing context made variable due to preceding '|' action" );
  960.  
  961.                 /* Mark as variable. */
  962.                 varlength = true;
  963.                 headcnt = 0;
  964.                 }
  965.  
  966.             if ( lex_compat || (varlength && headcnt == 0) )
  967.                 { /* variable trailing context rule */
  968.                 /* Mark the first part of the rule as the
  969.                  * accepting "head" part of a trailing
  970.                  * context rule.
  971.                  *
  972.                  * By the way, we didn't do this at the
  973.                  * beginning of this production because back
  974.                  * then current_state_type was set up for a
  975.                  * trail rule, and add_accept() can create
  976.                  * a new state ...
  977.                  */
  978.                 add_accept( yyvsp[-1],
  979.                     num_rules | YY_TRAILING_HEAD_MASK );
  980.                 variable_trail_rule = true;
  981.                 }
  982.             
  983.             else
  984.                 trailcnt = rulelen;
  985.  
  986.             yyval = link_machines( yyvsp[-1], yyvsp[0] );
  987.             }
  988. break;
  989. case 36:
  990. #line 421 "./parse.y"
  991. { synerr( "trailing context used twice" ); }
  992. break;
  993. case 37:
  994. #line 424 "./parse.y"
  995. {
  996.             headcnt = 0;
  997.             trailcnt = 1;
  998.             rulelen = 1;
  999.             varlength = false;
  1000.  
  1001.             current_state_type = STATE_TRAILING_CONTEXT;
  1002.  
  1003.             if ( trlcontxt )
  1004.                 {
  1005.                 synerr( "trailing context used twice" );
  1006.                 yyval = mkstate( SYM_EPSILON );
  1007.                 }
  1008.  
  1009.             else if ( previous_continued_action )
  1010.                 {
  1011.                 /* See the comment in the rule for "re2 re"
  1012.                  * above.
  1013.                  */
  1014.                 warn(
  1015.         "trailing context made variable due to preceding '|' action" );
  1016.  
  1017.                 varlength = true;
  1018.                 }
  1019.  
  1020.             if ( lex_compat || varlength )
  1021.                 {
  1022.                 /* Again, see the comment in the rule for
  1023.                  * "re2 re" above.
  1024.                  */
  1025.                 add_accept( yyvsp[-1],
  1026.                     num_rules | YY_TRAILING_HEAD_MASK );
  1027.                 variable_trail_rule = true;
  1028.                 }
  1029.  
  1030.             trlcontxt = true;
  1031.  
  1032.             eps = mkstate( SYM_EPSILON );
  1033.             yyval = link_machines( yyvsp[-1],
  1034.                 link_machines( eps, mkstate( '\n' ) ) );
  1035.             }
  1036. break;
  1037. case 38:
  1038. #line 467 "./parse.y"
  1039. {
  1040.             yyval = yyvsp[0];
  1041.  
  1042.             if ( trlcontxt )
  1043.                 {
  1044.                 if ( lex_compat || (varlength && headcnt == 0) )
  1045.                     /* Both head and trail are
  1046.                      * variable-length.
  1047.                      */
  1048.                     variable_trail_rule = true;
  1049.                 else
  1050.                     trailcnt = rulelen;
  1051.                 }
  1052.             }
  1053. break;
  1054. case 39:
  1055. #line 485 "./parse.y"
  1056. {
  1057.             varlength = true;
  1058.             yyval = mkor( yyvsp[-2], yyvsp[0] );
  1059.             }
  1060. break;
  1061. case 40:
  1062. #line 491 "./parse.y"
  1063. { yyval = yyvsp[0]; }
  1064. break;
  1065. case 41:
  1066. #line 496 "./parse.y"
  1067. {
  1068.             /* This rule is written separately so the
  1069.              * reduction will occur before the trailing
  1070.              * series is parsed.
  1071.              */
  1072.  
  1073.             if ( trlcontxt )
  1074.                 synerr( "trailing context used twice" );
  1075.             else
  1076.                 trlcontxt = true;
  1077.  
  1078.             if ( varlength )
  1079.                 /* We hope the trailing context is
  1080.                  * fixed-length.
  1081.                  */
  1082.                 varlength = false;
  1083.             else
  1084.                 headcnt = rulelen;
  1085.  
  1086.             rulelen = 0;
  1087.  
  1088.             current_state_type = STATE_TRAILING_CONTEXT;
  1089.             yyval = yyvsp[-1];
  1090.             }
  1091. break;
  1092. case 42:
  1093. #line 523 "./parse.y"
  1094. {
  1095.             /* This is where concatenation of adjacent patterns
  1096.              * gets done.
  1097.              */
  1098.             yyval = link_machines( yyvsp[-1], yyvsp[0] );
  1099.             }
  1100. break;
  1101. case 43:
  1102. #line 531 "./parse.y"
  1103. { yyval = yyvsp[0]; }
  1104. break;
  1105. case 44:
  1106. #line 535 "./parse.y"
  1107. {
  1108.             varlength = true;
  1109.  
  1110.             yyval = mkclos( yyvsp[-1] );
  1111.             }
  1112. break;
  1113. case 45:
  1114. #line 542 "./parse.y"
  1115. {
  1116.             varlength = true;
  1117.             yyval = mkposcl( yyvsp[-1] );
  1118.             }
  1119. break;
  1120. case 46:
  1121. #line 548 "./parse.y"
  1122. {
  1123.             varlength = true;
  1124.             yyval = mkopt( yyvsp[-1] );
  1125.             }
  1126. break;
  1127. case 47:
  1128. #line 554 "./parse.y"
  1129. {
  1130.             varlength = true;
  1131.  
  1132.             if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
  1133.                 {
  1134.                 synerr( "bad iteration values" );
  1135.                 yyval = yyvsp[-5];
  1136.                 }
  1137.             else
  1138.                 {
  1139.                 if ( yyvsp[-3] == 0 )
  1140.                     {
  1141.                     if ( yyvsp[-1] <= 0 )
  1142.                         {
  1143.                         synerr(
  1144.                         "bad iteration values" );
  1145.                         yyval = yyvsp[-5];
  1146.                         }
  1147.                     else
  1148.                         yyval = mkopt(
  1149.                             mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
  1150.                     }
  1151.                 else
  1152.                     yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
  1153.                 }
  1154.             }
  1155. break;
  1156. case 48:
  1157. #line 582 "./parse.y"
  1158. {
  1159.             varlength = true;
  1160.  
  1161.             if ( yyvsp[-2] <= 0 )
  1162.                 {
  1163.                 synerr( "iteration value must be positive" );
  1164.                 yyval = yyvsp[-4];
  1165.                 }
  1166.  
  1167.             else
  1168.                 yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITY );
  1169.             }
  1170. break;
  1171. case 49:
  1172. #line 596 "./parse.y"
  1173. {
  1174.             /* The singleton could be something like "(foo)",
  1175.              * in which case we have no idea what its length
  1176.              * is, so we punt here.
  1177.              */
  1178.             varlength = true;
  1179.  
  1180.             if ( yyvsp[-1] <= 0 )
  1181.                 {
  1182.                 synerr( "iteration value must be positive" );
  1183.                 yyval = yyvsp[-3];
  1184.                 }
  1185.  
  1186.             else
  1187.                 yyval = link_machines( yyvsp[-3],
  1188.                         copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
  1189.             }
  1190. break;
  1191. case 50:
  1192. #line 615 "./parse.y"
  1193. {
  1194.             if ( ! madeany )
  1195.                 {
  1196.                 /* Create the '.' character class. */
  1197.                 anyccl = cclinit();
  1198.                 ccladd( anyccl, '\n' );
  1199.                 cclnegate( anyccl );
  1200.  
  1201.                 if ( useecs )
  1202.                     mkeccl( ccltbl + cclmap[anyccl],
  1203.                         ccllen[anyccl], nextecm,
  1204.                         ecgroup, csize, csize );
  1205.  
  1206.                 madeany = true;
  1207.                 }
  1208.  
  1209.             ++rulelen;
  1210.  
  1211.             yyval = mkstate( -anyccl );
  1212.             }
  1213. break;
  1214. case 51:
  1215. #line 637 "./parse.y"
  1216. {
  1217.             if ( ! cclsorted )
  1218.                 /* Sort characters for fast searching.  We
  1219.                  * use a shell sort since this list could
  1220.                  * be large.
  1221.                  */
  1222.                 cshell( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], true );
  1223.  
  1224.             if ( useecs )
  1225.                 mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]],
  1226.                     nextecm, ecgroup, csize, csize );
  1227.  
  1228.             ++rulelen;
  1229.  
  1230.             yyval = mkstate( -yyvsp[0] );
  1231.             }
  1232. break;
  1233. case 52:
  1234. #line 655 "./parse.y"
  1235. {
  1236.             ++rulelen;
  1237.  
  1238.             yyval = mkstate( -yyvsp[0] );
  1239.             }
  1240. break;
  1241. case 53:
  1242. #line 662 "./parse.y"
  1243. { yyval = yyvsp[-1]; }
  1244. break;
  1245. case 54:
  1246. #line 665 "./parse.y"
  1247. { yyval = yyvsp[-1]; }
  1248. break;
  1249. case 55:
  1250. #line 668 "./parse.y"
  1251. {
  1252.             ++rulelen;
  1253.  
  1254.             if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1255.                 yyvsp[0] = clower( yyvsp[0] );
  1256.  
  1257.             yyval = mkstate( yyvsp[0] );
  1258.             }
  1259. break;
  1260. case 56:
  1261. #line 679 "./parse.y"
  1262. { yyval = yyvsp[-1]; }
  1263. break;
  1264. case 57:
  1265. #line 682 "./parse.y"
  1266. {
  1267.             cclnegate( yyvsp[-1] );
  1268.             yyval = yyvsp[-1];
  1269.             }
  1270. break;
  1271. case 58:
  1272. #line 689 "./parse.y"
  1273. {
  1274.             if ( caseins )
  1275.                 {
  1276.                 if ( yyvsp[-2] >= 'A' && yyvsp[-2] <= 'Z' )
  1277.                     yyvsp[-2] = clower( yyvsp[-2] );
  1278.                 if ( yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1279.                     yyvsp[0] = clower( yyvsp[0] );
  1280.                 }
  1281.  
  1282.             if ( yyvsp[-2] > yyvsp[0] )
  1283.                 synerr( "negative range in character class" );
  1284.  
  1285.             else
  1286.                 {
  1287.                 for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
  1288.                     ccladd( yyvsp[-3], i );
  1289.  
  1290.                 /* Keep track if this ccl is staying in
  1291.                  * alphabetical order.
  1292.                  */
  1293.                 cclsorted = cclsorted && (yyvsp[-2] > lastchar);
  1294.                 lastchar = yyvsp[0];
  1295.                 }
  1296.  
  1297.             yyval = yyvsp[-3];
  1298.             }
  1299. break;
  1300. case 59:
  1301. #line 717 "./parse.y"
  1302. {
  1303.             if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1304.                 yyvsp[0] = clower( yyvsp[0] );
  1305.  
  1306.             ccladd( yyvsp[-1], yyvsp[0] );
  1307.             cclsorted = cclsorted && (yyvsp[0] > lastchar);
  1308.             lastchar = yyvsp[0];
  1309.             yyval = yyvsp[-1];
  1310.             }
  1311. break;
  1312. case 60:
  1313. #line 728 "./parse.y"
  1314. {
  1315.             /* Too hard to properly maintain cclsorted. */
  1316.             cclsorted = false;
  1317.             yyval = yyvsp[-1];
  1318.             }
  1319. break;
  1320. case 61:
  1321. #line 735 "./parse.y"
  1322. {
  1323.             cclsorted = true;
  1324.             lastchar = 0;
  1325.             currccl = yyval = cclinit();
  1326.             }
  1327. break;
  1328. case 62:
  1329. #line 742 "./parse.y"
  1330. { CCL_EXPR(isalnum) }
  1331. break;
  1332. case 63:
  1333. #line 743 "./parse.y"
  1334. { CCL_EXPR(isalpha) }
  1335. break;
  1336. case 64:
  1337. #line 744 "./parse.y"
  1338. { CCL_EXPR(IS_BLANK) }
  1339. break;
  1340. case 65:
  1341. #line 745 "./parse.y"
  1342. { CCL_EXPR(iscntrl) }
  1343. break;
  1344. case 66:
  1345. #line 746 "./parse.y"
  1346. { CCL_EXPR(isdigit) }
  1347. break;
  1348. case 67:
  1349. #line 747 "./parse.y"
  1350. { CCL_EXPR(isgraph) }
  1351. break;
  1352. case 68:
  1353. #line 748 "./parse.y"
  1354. { CCL_EXPR(islower) }
  1355. break;
  1356. case 69:
  1357. #line 749 "./parse.y"
  1358. { CCL_EXPR(isprint) }
  1359. break;
  1360. case 70:
  1361. #line 750 "./parse.y"
  1362. { CCL_EXPR(ispunct) }
  1363. break;
  1364. case 71:
  1365. #line 751 "./parse.y"
  1366. { CCL_EXPR(isspace) }
  1367. break;
  1368. case 72:
  1369. #line 752 "./parse.y"
  1370. {
  1371.                 if ( caseins )
  1372.                     CCL_EXPR(islower)
  1373.                 else
  1374.                     CCL_EXPR(isupper)
  1375.                 }
  1376. break;
  1377. case 73:
  1378. #line 758 "./parse.y"
  1379. { CCL_EXPR(isxdigit) }
  1380. break;
  1381. case 74:
  1382. #line 762 "./parse.y"
  1383. {
  1384.             if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
  1385.                 yyvsp[0] = clower( yyvsp[0] );
  1386.  
  1387.             ++rulelen;
  1388.  
  1389.             yyval = link_machines( yyvsp[-1], mkstate( yyvsp[0] ) );
  1390.             }
  1391. break;
  1392. case 75:
  1393. #line 772 "./parse.y"
  1394. { yyval = mkstate( SYM_EPSILON ); }
  1395. break;
  1396. #line 1397 "y.tab.c"
  1397.     }
  1398.     yyssp -= yym;
  1399.     yystate = *yyssp;
  1400.     yyvsp -= yym;
  1401.     yym = yylhs[yyn];
  1402.     if (yystate == 0 && yym == 0)
  1403.     {
  1404. #if YYDEBUG
  1405.         if (yydebug)
  1406.             printf("%sdebug: after reduction, shifting from state 0 to\
  1407.  state %d\n", YYPREFIX, YYFINAL);
  1408. #endif
  1409.         yystate = YYFINAL;
  1410.         *++yyssp = YYFINAL;
  1411.         *++yyvsp = yyval;
  1412.         if (yychar < 0)
  1413.         {
  1414.             if ((yychar = yylex()) < 0) yychar = 0;
  1415. #if YYDEBUG
  1416.             if (yydebug)
  1417.             {
  1418.                 yys = 0;
  1419.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  1420.                 if (!yys) yys = "illegal-symbol";
  1421.                 printf("%sdebug: state %d, reading %d (%s)\n",
  1422.                         YYPREFIX, YYFINAL, yychar, yys);
  1423.             }
  1424. #endif
  1425.         }
  1426.         if (yychar == 0) goto yyaccept;
  1427.         goto yyloop;
  1428.     }
  1429.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
  1430.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  1431.         yystate = yytable[yyn];
  1432.     else
  1433.         yystate = yydgoto[yym];
  1434. #if YYDEBUG
  1435.     if (yydebug)
  1436.         printf("%sdebug: after reduction, shifting from state %d \
  1437. to state %d\n", YYPREFIX, *yyssp, yystate);
  1438. #endif
  1439.     if (yyssp >= yyss + yystacksize - 1)
  1440.     {
  1441.         goto yyoverflow;
  1442.     }
  1443.     *++yyssp = yystate;
  1444.     *++yyvsp = yyval;
  1445.     goto yyloop;
  1446. yyoverflow:
  1447.     yyerror("yacc stack overflow");
  1448. yyabort:
  1449.     return (1);
  1450. yyaccept:
  1451.     return (0);
  1452. }
  1453.